<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>10.2. math — Mathematical functions &mdash; Python v2.6.2 documentation</title>
    <link rel="stylesheet" href="../_static/default.css" type="text/css" />
    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '../',
        VERSION:     '2.6.2',
        COLLAPSE_MODINDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
      };
    </script>
    <script type="text/javascript" src="../_static/jquery.js"></script>
    <script type="text/javascript" src="../_static/doctools.js"></script>
    <link rel="search" type="application/opensearchdescription+xml"
          title="Search within Python v2.6.2 documentation"
          href="../_static/opensearch.xml"/>
    <link rel="author" title="About these documents" href="../about.html" />
    <link rel="copyright" title="Copyright" href="../copyright.html" />
    <link rel="top" title="Python v2.6.2 documentation" href="../index.html" />
    <link rel="up" title="10. Numeric and Mathematical Modules" href="numeric.html" />
    <link rel="next" title="10.3. cmath — Mathematical functions for complex numbers" href="cmath.html" />
    <link rel="prev" title="10.1. numbers — Numeric abstract base classes" href="numbers.html" />
    <link rel="shortcut icon" type="image/png" href="../_static/py.png" />
 

  </head>
  <body>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="../modindex.html" title="Global Module Index"
             accesskey="M">modules</a> |</li>
        <li class="right" >
          <a href="cmath.html" title="10.3. cmath — Mathematical functions for complex numbers"
             accesskey="N">next</a> |</li>
        <li class="right" >
          <a href="numbers.html" title="10.1. numbers — Numeric abstract base classes"
             accesskey="P">previous</a> |</li>
        <li><img src="../_static/py.png" alt=""
                 style="vertical-align: middle; margin-top: -1px"/></li>
        <li><a href="../index.html">Python v2.6.2 documentation</a> &raquo;</li>

          <li><a href="index.html" >The Python Standard Library</a> &raquo;</li>
          <li><a href="numeric.html" accesskey="U">10. Numeric and Mathematical Modules</a> &raquo;</li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body">
            
  <div class="section" id="module-math">
<h1>10.2. <tt class="xref docutils literal"><span class="pre">math</span></tt> &#8212; Mathematical functions<a class="headerlink" href="#module-math" title="Permalink to this headline">¶</a></h1>
<p>This module is always available.  It provides access to the mathematical
functions defined by the C standard.</p>
<p>These functions cannot be used with complex numbers; use the functions of the
same name from the <a title="Mathematical functions for complex numbers." class="reference external" href="cmath.html#module-cmath"><tt class="xref docutils literal"><span class="pre">cmath</span></tt></a> module if you require support for complex
numbers.  The distinction between functions which support complex numbers and
those which don&#8217;t is made since most users do not want to learn quite as much
mathematics as required to understand complex numbers.  Receiving an exception
instead of a complex result allows earlier detection of the unexpected complex
number used as a parameter, so that the programmer can determine how and why it
was generated in the first place.</p>
<p>The following functions are provided by this module.  Except when explicitly
noted otherwise, all return values are floats.</p>
<div class="section" id="number-theoretic-and-representation-functions">
<h2>10.2.1. Number-theoretic and representation functions<a class="headerlink" href="#number-theoretic-and-representation-functions" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="math.ceil">
<tt class="descclassname">math.</tt><tt class="descname">ceil</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.ceil" title="Permalink to this definition">¶</a></dt>
<dd>Return the ceiling of <em>x</em> as a float, the smallest integer value greater than or
equal to <em>x</em>.</dd></dl>

<dl class="function">
<dt id="math.copysign">
<tt class="descclassname">math.</tt><tt class="descname">copysign</tt><big>(</big><em>x</em>, <em>y</em><big>)</big><a class="headerlink" href="#math.copysign" title="Permalink to this definition">¶</a></dt>
<dd><p>Return <em>x</em> with the sign of <em>y</em>. <tt class="docutils literal"><span class="pre">copysign</span></tt> copies the sign bit of an IEEE
754 float, <tt class="docutils literal"><span class="pre">copysign(1,</span> <span class="pre">-0.0)</span></tt> returns <em>-1.0</em>.</p>
<p>
<span class="versionmodified">New in version 2.6.</span></p>
</dd></dl>

<dl class="function">
<dt id="math.fabs">
<tt class="descclassname">math.</tt><tt class="descname">fabs</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.fabs" title="Permalink to this definition">¶</a></dt>
<dd>Return the absolute value of <em>x</em>.</dd></dl>

<dl class="function">
<dt id="math.factorial">
<tt class="descclassname">math.</tt><tt class="descname">factorial</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.factorial" title="Permalink to this definition">¶</a></dt>
<dd><p>Return <em>x</em> factorial.  Raises <a title="exceptions.ValueError" class="reference external" href="exceptions.html#exceptions.ValueError"><tt class="xref docutils literal"><span class="pre">ValueError</span></tt></a> if <em>x</em> is not integral or
is negative.</p>
<p>
<span class="versionmodified">New in version 2.6.</span></p>
</dd></dl>

<dl class="function">
<dt id="math.floor">
<tt class="descclassname">math.</tt><tt class="descname">floor</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.floor" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the floor of <em>x</em> as a float, the largest integer value less than or equal
to <em>x</em>.</p>
<p>
<span class="versionmodified">Changed in version 2.6: </span>Added <tt class="xref docutils literal"><span class="pre">__floor__()</span></tt> delegation.</p>
</dd></dl>

<dl class="function">
<dt id="math.fmod">
<tt class="descclassname">math.</tt><tt class="descname">fmod</tt><big>(</big><em>x</em>, <em>y</em><big>)</big><a class="headerlink" href="#math.fmod" title="Permalink to this definition">¶</a></dt>
<dd>Return <tt class="docutils literal"><span class="pre">fmod(x,</span> <span class="pre">y)</span></tt>, as defined by the platform C library. Note that the
Python expression <tt class="docutils literal"><span class="pre">x</span> <span class="pre">%</span> <span class="pre">y</span></tt> may not return the same result.  The intent of the C
standard is that <tt class="docutils literal"><span class="pre">fmod(x,</span> <span class="pre">y)</span></tt> be exactly (mathematically; to infinite
precision) equal to <tt class="docutils literal"><span class="pre">x</span> <span class="pre">-</span> <span class="pre">n*y</span></tt> for some integer <em>n</em> such that the result has
the same sign as <em>x</em> and magnitude less than <tt class="docutils literal"><span class="pre">abs(y)</span></tt>.  Python&#8217;s <tt class="docutils literal"><span class="pre">x</span> <span class="pre">%</span> <span class="pre">y</span></tt>
returns a result with the sign of <em>y</em> instead, and may not be exactly computable
for float arguments. For example, <tt class="docutils literal"><span class="pre">fmod(-1e-100,</span> <span class="pre">1e100)</span></tt> is <tt class="docutils literal"><span class="pre">-1e-100</span></tt>, but
the result of Python&#8217;s <tt class="docutils literal"><span class="pre">-1e-100</span> <span class="pre">%</span> <span class="pre">1e100</span></tt> is <tt class="docutils literal"><span class="pre">1e100-1e-100</span></tt>, which cannot be
represented exactly as a float, and rounds to the surprising <tt class="docutils literal"><span class="pre">1e100</span></tt>.  For
this reason, function <a title="math.fmod" class="reference internal" href="#math.fmod"><tt class="xref docutils literal"><span class="pre">fmod()</span></tt></a> is generally preferred when working with
floats, while Python&#8217;s <tt class="docutils literal"><span class="pre">x</span> <span class="pre">%</span> <span class="pre">y</span></tt> is preferred when working with integers.</dd></dl>

<dl class="function">
<dt id="math.frexp">
<tt class="descclassname">math.</tt><tt class="descname">frexp</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.frexp" title="Permalink to this definition">¶</a></dt>
<dd>Return the mantissa and exponent of <em>x</em> as the pair <tt class="docutils literal"><span class="pre">(m,</span> <span class="pre">e)</span></tt>.  <em>m</em> is a float
and <em>e</em> is an integer such that <tt class="docutils literal"><span class="pre">x</span> <span class="pre">==</span> <span class="pre">m</span> <span class="pre">*</span> <span class="pre">2**e</span></tt> exactly. If <em>x</em> is zero,
returns <tt class="docutils literal"><span class="pre">(0.0,</span> <span class="pre">0)</span></tt>, otherwise <tt class="docutils literal"><span class="pre">0.5</span> <span class="pre">&lt;=</span> <span class="pre">abs(m)</span> <span class="pre">&lt;</span> <span class="pre">1</span></tt>.  This is used to &#8220;pick
apart&#8221; the internal representation of a float in a portable way.</dd></dl>

<dl class="function">
<dt id="math.fsum">
<tt class="descclassname">math.</tt><tt class="descname">fsum</tt><big>(</big><em>iterable</em><big>)</big><a class="headerlink" href="#math.fsum" title="Permalink to this definition">¶</a></dt>
<dd><p>Return an accurate floating point sum of values in the iterable.  Avoids
loss of precision by tracking multiple intermediate partial sums:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="nb">sum</span><span class="p">([</span><span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">])</span>
<span class="go">0.99999999999999989</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">fsum</span><span class="p">([</span><span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">,</span> <span class="o">.</span><span class="mf">1</span><span class="p">])</span>
<span class="go">1.0</span>
</pre></div>
</div>
<p>The algorithm&#8217;s accuracy depends on IEEE-754 arithmetic guarantees and the
typical case where the rounding mode is half-even.  On some non-Windows
builds, the underlying C library uses extended precision addition and may
occasionally double-round an intermediate sum causing it to be off in its
least significant bit.</p>
<p>For further discussion and two alternative approaches, see the <a class="reference external" href="http://code.activestate.com/recipes/393090/">ASPN cookbook
recipes for accurate floating point summation</a>.</p>
<p>
<span class="versionmodified">New in version 2.6.</span></p>
</dd></dl>

<dl class="function">
<dt id="math.isinf">
<tt class="descclassname">math.</tt><tt class="descname">isinf</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.isinf" title="Permalink to this definition">¶</a></dt>
<dd><p>Checks if the float <em>x</em> is positive or negative infinite.</p>
<p>
<span class="versionmodified">New in version 2.6.</span></p>
</dd></dl>

<dl class="function">
<dt id="math.isnan">
<tt class="descclassname">math.</tt><tt class="descname">isnan</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.isnan" title="Permalink to this definition">¶</a></dt>
<dd><p>Checks if the float <em>x</em> is a NaN (not a number). NaNs are part of the
IEEE 754 standards. Operation like but not limited to <tt class="docutils literal"><span class="pre">inf</span> <span class="pre">*</span> <span class="pre">0</span></tt>,
<tt class="docutils literal"><span class="pre">inf</span> <span class="pre">/</span> <span class="pre">inf</span></tt> or any operation involving a NaN, e.g. <tt class="docutils literal"><span class="pre">nan</span> <span class="pre">*</span> <span class="pre">1</span></tt>, return
a NaN.</p>
<p>
<span class="versionmodified">New in version 2.6.</span></p>
</dd></dl>

<dl class="function">
<dt id="math.ldexp">
<tt class="descclassname">math.</tt><tt class="descname">ldexp</tt><big>(</big><em>x</em>, <em>i</em><big>)</big><a class="headerlink" href="#math.ldexp" title="Permalink to this definition">¶</a></dt>
<dd>Return <tt class="docutils literal"><span class="pre">x</span> <span class="pre">*</span> <span class="pre">(2**i)</span></tt>.  This is essentially the inverse of function
<a title="math.frexp" class="reference internal" href="#math.frexp"><tt class="xref docutils literal"><span class="pre">frexp()</span></tt></a>.</dd></dl>

<dl class="function">
<dt id="math.modf">
<tt class="descclassname">math.</tt><tt class="descname">modf</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.modf" title="Permalink to this definition">¶</a></dt>
<dd>Return the fractional and integer parts of <em>x</em>.  Both results carry the sign
of <em>x</em> and are floats.</dd></dl>

<dl class="function">
<dt id="math.trunc">
<tt class="descclassname">math.</tt><tt class="descname">trunc</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.trunc" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the <tt class="xref docutils literal"><span class="pre">Real</span></tt> value <em>x</em> truncated to an <tt class="xref docutils literal"><span class="pre">Integral</span></tt> (usually
a long integer). Delegates to <tt class="docutils literal"><span class="pre">x.__trunc__()</span></tt>.</p>
<p>
<span class="versionmodified">New in version 2.6.</span></p>
</dd></dl>

<p>Note that <a title="math.frexp" class="reference internal" href="#math.frexp"><tt class="xref docutils literal"><span class="pre">frexp()</span></tt></a> and <a title="math.modf" class="reference internal" href="#math.modf"><tt class="xref docutils literal"><span class="pre">modf()</span></tt></a> have a different call/return pattern
than their C equivalents: they take a single argument and return a pair of
values, rather than returning their second return value through an &#8216;output
parameter&#8217; (there is no such thing in Python).</p>
<p>For the <a title="math.ceil" class="reference internal" href="#math.ceil"><tt class="xref docutils literal"><span class="pre">ceil()</span></tt></a>, <a title="math.floor" class="reference internal" href="#math.floor"><tt class="xref docutils literal"><span class="pre">floor()</span></tt></a>, and <a title="math.modf" class="reference internal" href="#math.modf"><tt class="xref docutils literal"><span class="pre">modf()</span></tt></a> functions, note that <em>all</em>
floating-point numbers of sufficiently large magnitude are exact integers.
Python floats typically carry no more than 53 bits of precision (the same as the
platform C double type), in which case any float <em>x</em> with <tt class="docutils literal"><span class="pre">abs(x)</span> <span class="pre">&gt;=</span> <span class="pre">2**52</span></tt>
necessarily has no fractional bits.</p>
</div>
<div class="section" id="power-and-logarithmic-functions">
<h2>10.2.2. Power and logarithmic functions<a class="headerlink" href="#power-and-logarithmic-functions" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="math.exp">
<tt class="descclassname">math.</tt><tt class="descname">exp</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.exp" title="Permalink to this definition">¶</a></dt>
<dd>Return <tt class="docutils literal"><span class="pre">e**x</span></tt>.</dd></dl>

<dl class="function">
<dt id="math.log">
<tt class="descclassname">math.</tt><tt class="descname">log</tt><big>(</big><em>x</em><span class="optional">[</span>, <em>base</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#math.log" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the logarithm of <em>x</em> to the given <em>base</em>. If the <em>base</em> is not specified,
return the natural logarithm of <em>x</em> (that is, the logarithm to base <em>e</em>).</p>
<p>
<span class="versionmodified">Changed in version 2.3: </span><em>base</em> argument added.</p>
</dd></dl>

<dl class="function">
<dt id="math.log1p">
<tt class="descclassname">math.</tt><tt class="descname">log1p</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.log1p" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the natural logarithm of <em>1+x</em> (base <em>e</em>). The
result is calculated in a way which is accurate for <em>x</em> near zero.</p>
<p>
<span class="versionmodified">New in version 2.6.</span></p>
</dd></dl>

<dl class="function">
<dt id="math.log10">
<tt class="descclassname">math.</tt><tt class="descname">log10</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.log10" title="Permalink to this definition">¶</a></dt>
<dd>Return the base-10 logarithm of <em>x</em>.</dd></dl>

<dl class="function">
<dt id="math.pow">
<tt class="descclassname">math.</tt><tt class="descname">pow</tt><big>(</big><em>x</em>, <em>y</em><big>)</big><a class="headerlink" href="#math.pow" title="Permalink to this definition">¶</a></dt>
<dd><p>Return <tt class="docutils literal"><span class="pre">x</span></tt> raised to the power <tt class="docutils literal"><span class="pre">y</span></tt>.  Exceptional cases follow
Annex &#8216;F&#8217; of the C99 standard as far as possible.  In particular,
<tt class="docutils literal"><span class="pre">pow(1.0,</span> <span class="pre">x)</span></tt> and <tt class="docutils literal"><span class="pre">pow(x,</span> <span class="pre">0.0)</span></tt> always return <tt class="docutils literal"><span class="pre">1.0</span></tt>, even
when <tt class="docutils literal"><span class="pre">x</span></tt> is a zero or a NaN.  If both <tt class="docutils literal"><span class="pre">x</span></tt> and <tt class="docutils literal"><span class="pre">y</span></tt> are finite,
<tt class="docutils literal"><span class="pre">x</span></tt> is negative, and <tt class="docutils literal"><span class="pre">y</span></tt> is not an integer then <tt class="docutils literal"><span class="pre">pow(x,</span> <span class="pre">y)</span></tt>
is undefined, and raises <a title="exceptions.ValueError" class="reference external" href="exceptions.html#exceptions.ValueError"><tt class="xref docutils literal"><span class="pre">ValueError</span></tt></a>.</p>
<p>
<span class="versionmodified">Changed in version 2.6: </span>The outcome of <tt class="docutils literal"><span class="pre">1**nan</span></tt> and <tt class="docutils literal"><span class="pre">nan**0</span></tt> was undefined.</p>
</dd></dl>

<dl class="function">
<dt id="math.sqrt">
<tt class="descclassname">math.</tt><tt class="descname">sqrt</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.sqrt" title="Permalink to this definition">¶</a></dt>
<dd>Return the square root of <em>x</em>.</dd></dl>

</div>
<div class="section" id="trigonometric-functions">
<h2>10.2.3. Trigonometric functions<a class="headerlink" href="#trigonometric-functions" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="math.acos">
<tt class="descclassname">math.</tt><tt class="descname">acos</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.acos" title="Permalink to this definition">¶</a></dt>
<dd>Return the arc cosine of <em>x</em>, in radians.</dd></dl>

<dl class="function">
<dt id="math.asin">
<tt class="descclassname">math.</tt><tt class="descname">asin</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.asin" title="Permalink to this definition">¶</a></dt>
<dd>Return the arc sine of <em>x</em>, in radians.</dd></dl>

<dl class="function">
<dt id="math.atan">
<tt class="descclassname">math.</tt><tt class="descname">atan</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.atan" title="Permalink to this definition">¶</a></dt>
<dd>Return the arc tangent of <em>x</em>, in radians.</dd></dl>

<dl class="function">
<dt id="math.atan2">
<tt class="descclassname">math.</tt><tt class="descname">atan2</tt><big>(</big><em>y</em>, <em>x</em><big>)</big><a class="headerlink" href="#math.atan2" title="Permalink to this definition">¶</a></dt>
<dd>Return <tt class="docutils literal"><span class="pre">atan(y</span> <span class="pre">/</span> <span class="pre">x)</span></tt>, in radians. The result is between <tt class="docutils literal"><span class="pre">-pi</span></tt> and <tt class="docutils literal"><span class="pre">pi</span></tt>.
The vector in the plane from the origin to point <tt class="docutils literal"><span class="pre">(x,</span> <span class="pre">y)</span></tt> makes this angle
with the positive X axis. The point of <a title="math.atan2" class="reference internal" href="#math.atan2"><tt class="xref docutils literal"><span class="pre">atan2()</span></tt></a> is that the signs of both
inputs are known to it, so it can compute the correct quadrant for the angle.
For example, <tt class="docutils literal"><span class="pre">atan(1</span></tt>) and <tt class="docutils literal"><span class="pre">atan2(1,</span> <span class="pre">1)</span></tt> are both <tt class="docutils literal"><span class="pre">pi/4</span></tt>, but <tt class="docutils literal"><span class="pre">atan2(-1,</span>
<span class="pre">-1)</span></tt> is <tt class="docutils literal"><span class="pre">-3*pi/4</span></tt>.</dd></dl>

<dl class="function">
<dt id="math.cos">
<tt class="descclassname">math.</tt><tt class="descname">cos</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.cos" title="Permalink to this definition">¶</a></dt>
<dd>Return the cosine of <em>x</em> radians.</dd></dl>

<dl class="function">
<dt id="math.hypot">
<tt class="descclassname">math.</tt><tt class="descname">hypot</tt><big>(</big><em>x</em>, <em>y</em><big>)</big><a class="headerlink" href="#math.hypot" title="Permalink to this definition">¶</a></dt>
<dd>Return the Euclidean norm, <tt class="docutils literal"><span class="pre">sqrt(x*x</span> <span class="pre">+</span> <span class="pre">y*y)</span></tt>. This is the length of the vector
from the origin to point <tt class="docutils literal"><span class="pre">(x,</span> <span class="pre">y)</span></tt>.</dd></dl>

<dl class="function">
<dt id="math.sin">
<tt class="descclassname">math.</tt><tt class="descname">sin</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.sin" title="Permalink to this definition">¶</a></dt>
<dd>Return the sine of <em>x</em> radians.</dd></dl>

<dl class="function">
<dt id="math.tan">
<tt class="descclassname">math.</tt><tt class="descname">tan</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.tan" title="Permalink to this definition">¶</a></dt>
<dd>Return the tangent of <em>x</em> radians.</dd></dl>

</div>
<div class="section" id="angular-conversion">
<h2>10.2.4. Angular conversion<a class="headerlink" href="#angular-conversion" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="math.degrees">
<tt class="descclassname">math.</tt><tt class="descname">degrees</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.degrees" title="Permalink to this definition">¶</a></dt>
<dd>Converts angle <em>x</em> from radians to degrees.</dd></dl>

<dl class="function">
<dt id="math.radians">
<tt class="descclassname">math.</tt><tt class="descname">radians</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.radians" title="Permalink to this definition">¶</a></dt>
<dd>Converts angle <em>x</em> from degrees to radians.</dd></dl>

</div>
<div class="section" id="hyperbolic-functions">
<h2>10.2.5. Hyperbolic functions<a class="headerlink" href="#hyperbolic-functions" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="math.acosh">
<tt class="descclassname">math.</tt><tt class="descname">acosh</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.acosh" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the inverse hyperbolic cosine of <em>x</em>.</p>
<p>
<span class="versionmodified">New in version 2.6.</span></p>
</dd></dl>

<dl class="function">
<dt id="math.asinh">
<tt class="descclassname">math.</tt><tt class="descname">asinh</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.asinh" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the inverse hyperbolic sine of <em>x</em>.</p>
<p>
<span class="versionmodified">New in version 2.6.</span></p>
</dd></dl>

<dl class="function">
<dt id="math.atanh">
<tt class="descclassname">math.</tt><tt class="descname">atanh</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.atanh" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the inverse hyperbolic tangent of <em>x</em>.</p>
<p>
<span class="versionmodified">New in version 2.6.</span></p>
</dd></dl>

<dl class="function">
<dt id="math.cosh">
<tt class="descclassname">math.</tt><tt class="descname">cosh</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.cosh" title="Permalink to this definition">¶</a></dt>
<dd>Return the hyperbolic cosine of <em>x</em>.</dd></dl>

<dl class="function">
<dt id="math.sinh">
<tt class="descclassname">math.</tt><tt class="descname">sinh</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.sinh" title="Permalink to this definition">¶</a></dt>
<dd>Return the hyperbolic sine of <em>x</em>.</dd></dl>

<dl class="function">
<dt id="math.tanh">
<tt class="descclassname">math.</tt><tt class="descname">tanh</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#math.tanh" title="Permalink to this definition">¶</a></dt>
<dd>Return the hyperbolic tangent of <em>x</em>.</dd></dl>

</div>
<div class="section" id="constants">
<h2>10.2.6. Constants<a class="headerlink" href="#constants" title="Permalink to this headline">¶</a></h2>
<dl class="data">
<dt id="math.pi">
<tt class="descclassname">math.</tt><tt class="descname">pi</tt><a class="headerlink" href="#math.pi" title="Permalink to this definition">¶</a></dt>
<dd>The mathematical constant <em>pi</em>.</dd></dl>

<dl class="data">
<dt id="math.e">
<tt class="descclassname">math.</tt><tt class="descname">e</tt><a class="headerlink" href="#math.e" title="Permalink to this definition">¶</a></dt>
<dd>The mathematical constant <em>e</em>.</dd></dl>

<div class="admonition note">
<p class="first admonition-title">Note</p>
<p>The <tt class="xref docutils literal"><span class="pre">math</span></tt> module consists mostly of thin wrappers around the platform C
math library functions.  Behavior in exceptional cases is loosely specified
by the C standards, and Python inherits much of its math-function
error-reporting behavior from the platform C implementation.  As a result,
the specific exceptions raised in error cases (and even whether some
arguments are considered to be exceptional at all) are not defined in any
useful cross-platform or cross-release way.  For example, whether
<tt class="docutils literal"><span class="pre">math.log(0)</span></tt> returns <tt class="docutils literal"><span class="pre">-Inf</span></tt> or raises <a title="exceptions.ValueError" class="reference external" href="exceptions.html#exceptions.ValueError"><tt class="xref docutils literal"><span class="pre">ValueError</span></tt></a> or
<a title="exceptions.OverflowError" class="reference external" href="exceptions.html#exceptions.OverflowError"><tt class="xref docutils literal"><span class="pre">OverflowError</span></tt></a> isn&#8217;t defined, and in cases where <tt class="docutils literal"><span class="pre">math.log(0)</span></tt> raises
<a title="exceptions.OverflowError" class="reference external" href="exceptions.html#exceptions.OverflowError"><tt class="xref docutils literal"><span class="pre">OverflowError</span></tt></a>, <tt class="docutils literal"><span class="pre">math.log(0L)</span></tt> may raise <a title="exceptions.ValueError" class="reference external" href="exceptions.html#exceptions.ValueError"><tt class="xref docutils literal"><span class="pre">ValueError</span></tt></a> instead.</p>
<p>All functions return a quiet <em>NaN</em> if at least one of the args is <em>NaN</em>.
Signaling <em>NaN</em>s raise an exception. The exception type still depends on the
platform and libm implementation. It&#8217;s usually <a title="exceptions.ValueError" class="reference external" href="exceptions.html#exceptions.ValueError"><tt class="xref docutils literal"><span class="pre">ValueError</span></tt></a> for <em>EDOM</em>
and <a title="exceptions.OverflowError" class="reference external" href="exceptions.html#exceptions.OverflowError"><tt class="xref docutils literal"><span class="pre">OverflowError</span></tt></a> for errno <em>ERANGE</em>.</p>
<p class="last">
<span class="versionmodified">Changed in version 2.6: </span>In earlier versions of Python the outcome of an operation with NaN as
input depended on platform and libm implementation.</p>
</div>
<div class="admonition-see-also admonition seealso">
<p class="first admonition-title">See also</p>
<dl class="last docutils">
<dt>Module <a title="Mathematical functions for complex numbers." class="reference external" href="cmath.html#module-cmath"><tt class="xref docutils literal"><span class="pre">cmath</span></tt></a></dt>
<dd>Complex number versions of many of these functions.</dd>
</dl>
</div>
</div>
</div>


          </div>
        </div>
      </div>
      <div class="sphinxsidebar">
        <div class="sphinxsidebarwrapper">
            <h3><a href="../contents.html">Table Of Contents</a></h3>
            <ul>
<li><a class="reference external" href="">10.2. <tt class="docutils literal"><span class="pre">math</span></tt> &#8212; Mathematical functions</a><ul>
<li><a class="reference external" href="#number-theoretic-and-representation-functions">10.2.1. Number-theoretic and representation functions</a></li>
<li><a class="reference external" href="#power-and-logarithmic-functions">10.2.2. Power and logarithmic functions</a></li>
<li><a class="reference external" href="#trigonometric-functions">10.2.3. Trigonometric functions</a></li>
<li><a class="reference external" href="#angular-conversion">10.2.4. Angular conversion</a></li>
<li><a class="reference external" href="#hyperbolic-functions">10.2.5. Hyperbolic functions</a></li>
<li><a class="reference external" href="#constants">10.2.6. Constants</a></li>
</ul>
</li>
</ul>

            <h4>Previous topic</h4>
            <p class="topless"><a href="numbers.html"
                                  title="previous chapter">10.1. <tt class="docutils literal"><span class="pre">numbers</span></tt> &#8212; Numeric abstract base classes</a></p>
            <h4>Next topic</h4>
            <p class="topless"><a href="cmath.html"
                                  title="next chapter">10.3. <tt class="docutils literal docutils literal docutils literal"><span class="pre">cmath</span></tt> &#8212; Mathematical functions for complex numbers</a></p>
            <h3>This Page</h3>
            <ul class="this-page-menu">
              <li><a href="../_sources/library/math.txt"
                     rel="nofollow">Show Source</a></li>
            </ul>
          <div id="searchbox" style="display: none">
            <h3>Quick search</h3>
              <form class="search" action="../search.html" method="get">
                <input type="text" name="q" size="18" />
                <input type="submit" value="Go" />
                <input type="hidden" name="check_keywords" value="yes" />
                <input type="hidden" name="area" value="default" />
              </form>
              <p class="searchtip" style="font-size: 90%">
              Enter search terms or a module, class or function name.
              </p>
          </div>
          <script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="../modindex.html" title="Global Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="cmath.html" title="10.3. cmath — Mathematical functions for complex numbers"
             >next</a> |</li>
        <li class="right" >
          <a href="numbers.html" title="10.1. numbers — Numeric abstract base classes"
             >previous</a> |</li>
        <li><img src="../_static/py.png" alt=""
                 style="vertical-align: middle; margin-top: -1px"/></li>
        <li><a href="../index.html">Python v2.6.2 documentation</a> &raquo;</li>

          <li><a href="index.html" >The Python Standard Library</a> &raquo;</li>
          <li><a href="numeric.html" >10. Numeric and Mathematical Modules</a> &raquo;</li> 
      </ul>
    </div>
    <div class="footer">
      &copy; <a href="../copyright.html">Copyright</a> 1990-2009, Python Software Foundation.
      Last updated on Apr 15, 2009.
      Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 0.6.1.
    </div>
  </body>
</html>